package com.bsg.upm.check;

import java.text.MessageFormat;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpStatus;
import org.springframework.stereotype.Service;

import com.bsg.upm.constant.DictConstants;
import com.bsg.upm.constant.DictTypeConstants;
import com.bsg.upm.constant.Messages;
import com.bsg.upm.constant.SysConstants;
import com.bsg.upm.entity.HostEntity;
import com.bsg.upm.entity.TaskEntity;
import com.bsg.upm.entity.UnitEntity;

/**
 * 单元业务处理检查
 * 
 * @author HCK
 *
 */
@Service
public class UnitCheck extends BaseCheck {

	/**
	 * 单元启动时检查
	 * 
	 * @param unit
	 *            单元对象
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkStart(UnitEntity unit) {
		CheckResult chkRS = new CheckResult();
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法启动");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法启动");
			return chkRS;
		}
		return chkRS;
	}

	/**
	 * 单元停止时检查
	 * 
	 * @param unit
	 *            单元对象
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkStop(UnitEntity unit) {
		CheckResult chkRS = new CheckResult();
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法停止");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法停止");
			return chkRS;
		}
		return chkRS;
	}

	/**
	 * 单元备份时检查
	 * 
	 * @param paramMap
	 *            请求参数
	 * 
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkBackup(Map<String, Object> paramMap) {
		CheckResult chkRS = new CheckResult();

		if (paramMap.containsKey("type")) {
			// 备份类型非空检查
			String type = (String) paramMap.get("type");
			if (StringUtils.isBlank(type)) {
				chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
				chkRS.setErrorMsg(MessageFormat.format(Messages.NULL_NOT_ALLOWED, "备份类型"));
				return chkRS;
			}

			// 备份类型存在性检查
			if (dictTypeCache.getDictFromCache(DictTypeConstants.BACKUP_TYPE, type) == null) {
				chkRS.setStatus(HttpStatus.SC_GONE);
				chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "备份类型"));
				return chkRS;
			}
		}

		String unitId = (String) paramMap.get("unitId");
		UnitEntity unit = unitDao.get(unitId);
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法备份");
			return chkRS;
		}

		// 判断能否备份
		if (!unit.getSubServ().getSubOrder().getDefinitionSubServ().getCanBackup()) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该类型的单元不能备份");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法备份");
			return chkRS;
		}
		return chkRS;
	}

	/**
	 * 单元还原时检查
	 * 
	 * @param paramMap
	 *            请求参数
	 * 
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkRestore(Map<String, Object> paramMap) {
		CheckResult chkRS = new CheckResult();

		// 备份文件编码非空检查
		if (StringUtils.isBlank((String) paramMap.get("backupFileId"))) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("必须指定备份文件");
			return chkRS;
		}

		// 单元编码
		String unitId = (String) paramMap.get("unitId");
		// 获取指定单元
		UnitEntity unit = unitDao.get(unitId);
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法还原");
			return chkRS;
		}

		// 判断能否还原
		if (!unit.getSubServ().getSubOrder().getDefinitionSubServ().getCanBackup()) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该类型的单元不能还原");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法还原");
			return chkRS;
		}
		return chkRS;
	}

	/**
	 * 单元迁移时检查
	 * 
	 * @param paramMap
	 *            请求参数
	 * 
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkMigrate(Map<String, Object> paramMap) {
		CheckResult chkRS = new CheckResult();
		// 单元编码
		String unitId = (String) paramMap.get("unitId");
		// 获取指定单元
		UnitEntity unit = unitDao.get(unitId);
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法迁移");
			return chkRS;
		}

		// 迁移策略非空检查
		String strategy = (String) paramMap.get("strategy");

		if (StringUtils.isBlank(strategy)) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NULL_NOT_ALLOWED, "迁移策略"));
			return chkRS;
		}

		if (DictConstants.STRATEGY_MANUAL.equals(strategy)) {
			// 主机非空检查
			String hostId = (String) paramMap.get("host");
			if (StringUtils.isBlank(hostId)) {
				chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
				chkRS.setErrorMsg("迁移策略为指定主机时，必须指定主机");
				return chkRS;
			}

			// 主机存在性检查
			HostEntity host = hostDao.get(hostId);
			if (host == null) {
				chkRS.setStatus(HttpStatus.SC_GONE);
				chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "主机"));
				return chkRS;
			}

			// 主机状态检查
			if (!DictConstants.HOST_STATUS_ENABLE.equals(host.getStatus())) {
				chkRS.setStatus(HttpStatus.SC_GONE);
				chkRS.setErrorMsg("该主机不是启用状态");
				return chkRS;
			}
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法还原");
			return chkRS;
		}

		return chkRS;
	}

	/**
	 * 单元重建时检查
	 * 
	 * @param paramMap
	 *            请求参数
	 * 
	 * @return CheckResult检查结果对象
	 */
	public CheckResult checkRebuild(Map<String, Object> paramMap) {
		CheckResult chkRS = new CheckResult();
		// 单元编码
		String unitId = (String) paramMap.get("unitId");
		// 获取指定单元
		UnitEntity unit = unitDao.get(unitId);
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法重建");
			return chkRS;
		}

		// 迁移策略非空检查
		String strategy = (String) paramMap.get("strategy");

		if (StringUtils.isBlank(strategy)) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NULL_NOT_ALLOWED, "重建策略"));
			return chkRS;
		}

		if (DictConstants.STRATEGY_MANUAL.equals(strategy)) {
			// 主机非空检查
			String hostId = (String) paramMap.get("host");
			if (StringUtils.isBlank(hostId)) {
				chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
				chkRS.setErrorMsg("迁移策略为指定主机时，必须指定主机");
				return chkRS;
			}

			// 主机存在性检查
			HostEntity host = hostDao.get(hostId);
			if (host == null) {
				chkRS.setStatus(HttpStatus.SC_GONE);
				chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "主机"));
				return chkRS;
			}

			// 主机状态检查
			if (!DictConstants.HOST_STATUS_ENABLE.equals(host.getStatus())) {
				chkRS.setStatus(HttpStatus.SC_GONE);
				chkRS.setErrorMsg("该主机不是启用状态");
				return chkRS;
			}
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法还原");
			return chkRS;
		}

		return chkRS;
	}

	/**
	 * 单元隔离时检查
	 * 
	 * @param unit
	 *            单元对象
	 * @return 检查结果
	 */
	public CheckResult checkIsolate(UnitEntity unit) {
		CheckResult chkRS = new CheckResult();
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法隔离");
			return chkRS;
		}

		String servType = unit.getSubServ().getServ().getOrder().getDefinitionServ().getCode();
		String type = unit.getSubServ().getSubOrder().getDefinitionSubServ().getName();
		if (!SysConstants.SERV_UPSQL_UPPROXY_SWM_CODE.equals(servType)
				|| !SysConstants.SUBSERV_UPSQL_NAME.equals(type)) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该类型的单元不能隔离");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法隔离");
			return chkRS;
		}
		return chkRS;
	}

	/**
	 * 单元回切时检查
	 * 
	 * @param unit
	 *            单元对象
	 * @return 检查结果
	 */
	public CheckResult checkRecover(UnitEntity unit) {
		CheckResult chkRS = new CheckResult();
		// 存在性检查
		if (unit == null) {
			chkRS.setStatus(HttpStatus.SC_GONE);
			chkRS.setErrorMsg(MessageFormat.format(Messages.NOT_EXIST, "单元"));
			return chkRS;
		}

		// 判断是否创建成功（注：relateId为空时,一定未创建成功，relateId非空时不一定创建成功）
		if (StringUtils.isBlank(unit.getRelateId())) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该单元尚未创建成功，无法回切");
			return chkRS;
		}

		String servType = unit.getSubServ().getServ().getOrder().getDefinitionServ().getCode();
		String type = unit.getSubServ().getSubOrder().getDefinitionSubServ().getName();
		if (!SysConstants.SERV_UPSQL_UPPROXY_SWM_CODE.equals(servType)
				|| !SysConstants.SUBSERV_UPSQL_NAME.equals(type)) {
			chkRS.setStatus(HttpStatus.SC_BAD_REQUEST);
			chkRS.setErrorMsg("该类型的单元不能隔离");
			return chkRS;
		}

		// 单元任务状态检查(任务未结束不能执行其他任务)
		TaskEntity task = taskDao.getLatestTaskByObjId(unit.getId());
		if (task != null && task.getEndDateTime() == null) {
			chkRS.setStatus(HttpStatus.SC_CONFLICT);
			chkRS.setErrorMsg("该单元任务尚未结束，无法回切");
			return chkRS;
		}
		return chkRS;
	}

}
